/**
 * 统一响应格式工具
 */

/**
 * 成功响应
 * @param {Object} res - Express response object
 * @param {*} data - 响应数据
 * @param {string} message - 响应消息
 * @param {number} code - 响应码
 */
const success = (res, data = null, message = 'success', code = 200) => {
  return res.status(200).json({
    code,
    message,
    data,
    timestamp: Date.now()
  });
};

/**
 * 错误响应
 * @param {Object} res - Express response object
 * @param {string} message - 错误消息
 * @param {number} code - 错误码
 * @param {*} data - 错误数据
 */
const error = (res, message = '服务器内部错误', code = 500, data = null) => {
  return res.status(code >= 400 && code < 600 ? code : 500).json({
    code,
    message,
    data,
    timestamp: Date.now()
  });
};

/**
 * 分页响应
 * @param {Object} res - Express response object
 * @param {Array} list - 数据列表
 * @param {number} total - 总数
 * @param {number} page - 当前页
 * @param {number} limit - 每页数量
 * @param {Object} extra - 额外数据
 */
const paginated = (res, list, total, page, limit, extra = {}) => {
  return success(res, {
    list,
    total,
    page: parseInt(page),
    limit: parseInt(limit),
    totalPages: Math.ceil(total / limit),
    ...extra
  });
};

/**
 * 验证错误响应
 * @param {Object} res - Express response object
 * @param {Array} errors - 验证错误数组
 */
const validationError = (res, errors) => {
  return res.status(400).json({
    code: 400,
    message: '请求参数错误',
    data: {
      errors: errors.map(err => ({
        field: err.param,
        message: err.msg,
        value: err.value
      }))
    },
    timestamp: Date.now()
  });
};

/**
 * 未授权响应
 * @param {Object} res - Express response object
 * @param {string} message - 错误消息
 */
const unauthorized = (res, message = '未授权访问') => {
  return error(res, message, 401);
};

/**
 * 禁止访问响应
 * @param {Object} res - Express response object
 * @param {string} message - 错误消息
 */
const forbidden = (res, message = '禁止访问') => {
  return error(res, message, 403);
};

/**
 * 资源不存在响应
 * @param {Object} res - Express response object
 * @param {string} message - 错误消息
 */
const notFound = (res, message = '资源不存在') => {
  return error(res, message, 404);
};

/**
 * 参数错误响应
 * @param {Object} res - Express response object
 * @param {string} message - 错误消息
 */
const badRequest = (res, message = '请求参数错误') => {
  return error(res, message, 400);
};

/**
 * 格式化响应数据
 * @param {number} code - 状态码
 * @param {string} message - 消息
 * @param {*} data - 数据
 */
const formatResponse = (code, message, data) => {
  return {
    code,
    message,
    data,
    timestamp: Date.now()
  };
};

// 自定义错误类
class ServiceError extends Error {
  constructor(message, code = 500) {
    super(message);
    this.code = code;
    this.name = 'ServiceError';
  }

  toResponseJSON() {
    return formatResponse(this.code, this.message, null);
  }
}

class ValidationError extends ServiceError {
  constructor(message) {
    super(message, 400);
    this.name = 'ValidationError';
  }
}

class UnauthorizedError extends ServiceError {
  constructor(message = '未授权访问') {
    super(message, 401);
    this.name = 'UnauthorizedError';
  }
}

class ForbiddenError extends ServiceError {
  constructor(message = '禁止访问') {
    super(message, 403);
    this.name = 'ForbiddenError';
  }
}

class NotFoundError extends ServiceError {
  constructor(message = '资源不存在') {
    super(message, 404);
    this.name = 'NotFoundError';
  }
}

/**
 * 处理异步路由错误的包装器
 * @param {Function} fn - 异步路由处理函数
 */
const asyncHandler = (fn) => {
  return (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
};

/**
 * 全局错误处理中间件
 */
const errorHandler = (err, req, res, next) => {
  console.error('路由错误:', err);

  // 如果响应已经发送，则交给默认错误处理器
  if (res.headersSent) {
    return next(err);
  }

  // 数据库错误
  if (err.name === 'SequelizeValidationError') {
    return badRequest(res, '数据验证失败: ' + err.errors.map(e => e.message).join(', '));
  }

  if (err.name === 'SequelizeUniqueConstraintError') {
    return badRequest(res, '数据已存在，请检查输入');
  }

  if (err.name === 'SequelizeForeignKeyConstraintError') {
    return badRequest(res, '关联数据不存在');
  }

  // JWT错误
  if (err.name === 'JsonWebTokenError') {
    return unauthorized(res, '无效的访问令牌');
  }

  if (err.name === 'TokenExpiredError') {
    return unauthorized(res, '访问令牌已过期');
  }

  // 文件上传错误
  if (err.code === 'LIMIT_FILE_SIZE') {
    return badRequest(res, '文件大小超出限制');
  }

  if (err.code === 'LIMIT_FILE_COUNT') {
    return badRequest(res, '文件数量超出限制');
  }

  if (err.code === 'LIMIT_UNEXPECTED_FILE') {
    return badRequest(res, '不支持的文件类型');
  }

  // 自定义错误
  if (err.status) {
    return error(res, err.message, err.status);
  }

  // 默认服务器错误
  error(res, '服务器内部错误', 500);
};

module.exports = {
  formatResponse,
  success,
  error,
  badRequest,
  paginated,
  validationError,
  unauthorized,
  forbidden,
  notFound,
  asyncHandler,
  errorHandler,
  ServiceError,
  ValidationError,
  UnauthorizedError,
  ForbiddenError,
  NotFoundError
};
